// plugins/activeWindowPlugin.js
import plugin from '../../lib/plugins/plugin.js'
import { createServer } from 'http'
import express from 'express'
import bodyParser from 'body-parser'
import crypto from 'crypto' // 添加这行导入语句

let isDetectionActive = false
let masterWindowInfo = null

export class ActiveWindowPlugin extends plugin {
  constructor () {
    super({
      name: '活动窗口检测',
      dsc: '检测主人电脑当前活动窗口',
      event: 'message',
      priority: 5000,
      rule: [
        {
          reg: '^#?当前窗口$',
          fnc: 'getActiveWindow',
          permission: 'master'
        },
        {
          reg: '^#?系统状态$',
          fnc: 'getSystemStatus',
          permission: 'master'
        },
        {
          reg: '^#?窗口检测状态$',
          fnc: 'checkStatus',
          permission: 'master'
        },
        {
          reg: '^#?(启动|开始)窗口检测$',
          fnc: 'startDetection',
          permission: 'master'
        },
        {
          reg: '^#?(停止|结束)窗口检测$',
          fnc: 'stopDetection',
          permission: 'master'
        }
      ]
    })

    this.authConfig = {
      appid: '', // 客户端标识
      token: '', // 共享密钥
      timeout: 300000 // 5分钟有效期（毫秒）
    }

    this.isDetectionActive = isDetectionActive
    this.masterWindowInfo = masterWindowInfo
    this.app = express()
    this.server = null
    this.port = 5502

    this.app.use(bodyParser.json())

    // 验证函数
    this.verifyRequest = (req) => {
      const { timestamp, access_token, appid } = req.body

      // 基本字段检查
      if (!timestamp || !access_token || !appid) {
        console.log('[认证] 缺少必要字段')
        return false
      }

      // 应用ID检查
      if (appid !== this.authConfig.appid) {
        console.log(`[认证] 无效应用ID: ${appid}`)
        return false
      }

      // 时间戳有效性检查（5分钟内）
      const now = Date.now()
      if (Math.abs(now - parseInt(timestamp)) > this.authConfig.timeout) {
        console.log(`[认证] 过期请求: ${now - timestamp}ms`)
        return false
      }

      // 生成服务端签名
      const signStr = `${timestamp}:${appid}:${this.authConfig.token}`
      const serverSign = crypto
        .createHmac('sha256', this.authConfig.token)
        .update(signStr)
        .digest('hex')

      // 签名比对
      return serverSign === access_token
    }

    // 修改路由处理 - 添加认证
    this.app.post('/report', (req, res) => {
      // 认证检查
      if (!this.verifyRequest(req)) {
        console.log('[认证] 报告请求验证失败')
        res.status(403).send('Access denied')
        return
      }

      const { userId, appName, windowTitle, device_info } = req.body
      // 只处理master的请求
      if (userId === 'master' && appName && windowTitle) {
        masterWindowInfo = {
          device_info, // 存储设备信息
          appName,
          windowTitle,
          timestamp: Date.now()
        }
        console.log(`[活动窗口检测] 收到窗口报告: ${device_info.device_name} - ${appName} - ${windowTitle}`)
        res.status(200).send('OK')
      } else {
        res.status(403).send('Access denied')
      }
    })

    this.app.post('/status', (req, res) => {
      // 认证检查
      if (!this.verifyRequest(req)) {
        console.log('[认证] 状态请求验证失败')
        res.status(403).send('Access denied')
        return
      }

      const { userId, status } = req.body
      // 只处理master的请求
      if (userId === 'master' && status) {
        console.log(`[活动窗口检测] 收到状态更新: ${status}`)
        res.status(200).send('OK')
      } else {
        res.status(403).send('Access denied')
      }
    })

    this.app.get('/', (req, res) => {
      res.send('主人窗口检测服务已运行')
    })
  }

  // 启动HTTP服务器 - 绑定到 0.0.0.0
  async startServer () {
    if (this.server) {
      console.log('[活动窗口检测] 服务器已经启动')
      return
    }

    try {
      console.log('[活动窗口检测] 尝试启动服务器...')
      this.server = createServer(this.app)

      // 绑定到 0.0.0.0 允许所有网络接口访问
      this.server.listen(this.port, '0.0.0.0', () => {
        console.log(`[活动窗口检测] 服务已启动，监听端口 ${this.port}`)
      })

      // 添加错误处理
      this.server.on('error', (err) => {
        console.error(`[活动窗口检测] 服务器错误: ${err.message}`)
        if (err.code === 'EADDRINUSE') {
          console.error(`[活动窗口检测] 端口 ${this.port} 已被占用`)

          // 尝试使用其他端口
          this.port += 1
          console.log(`[活动窗口检测] 尝试使用端口 ${this.port}`)
          this.startServer()
        }
      })
    } catch (err) {
      console.error(`[活动窗口检测] 启动服务器失败: ${err.message}`)
    }
  }

  // 停止HTTP服务器
  async stopServer () {
    if (this.server) {
      return new Promise((resolve) => {
        this.server.close(() => {
          console.log('[活动窗口检测] 服务已停止')
          this.server = null
          resolve()
        })
      })
    }
    return Promise.resolve()
  }

  // 获取当前活动窗口 - 仅主人可用
  async getActiveWindow (e) {
    if (!e.isMaster) {
      return false // 非主人直接忽略
    }

    if (!this.isDetectionActive) {
      await e.reply('窗口检测未启动，请先使用"#启动窗口检测"')
      return true
    }

    if (!masterWindowInfo) {
      await e.reply('尚未收到窗口信息，请确保客户端已运行')
      return true
    }

    const timeDiff = Math.floor((Date.now() - masterWindowInfo.timestamp) / 1000)
    await e.reply([
      `💻 设备名称：${masterWindowInfo.device_info.device_name}`,
      `🖥️ 操作系统：${masterWindowInfo.device_info.os}`,
      `📱 当前应用：${masterWindowInfo.appName}`,
      `📝 窗口标题：${masterWindowInfo.windowTitle}`,
      `⏱ 更新时间：${timeDiff}秒前`
    ].join('\n'))

    return true
  }

  async getSystemStatus (e) {
    if (!e.isMaster) {
      return false
    }

    if (!this.isDetectionActive) {
      await e.reply('系统监控未启动，请先使用"#启动窗口检测"')
      return true
    }

    if (!masterWindowInfo) {
      await e.reply('尚未收到监控信息，请确保客户端已运行')
      return true
    }

    const { device_info } = masterWindowInfo
    const timeDiff = Math.floor((Date.now() - masterWindowInfo.timestamp) / 1000)

    // CPU信息格式化
    let cpuInfo = '❌ 未获取到CPU信息'
    if (device_info.cpu && Object.keys(device_info.cpu).length > 0) {
      const cpu = device_info.cpu
      cpuInfo = [
        `🔹 名称：${cpu.name || '未知'}`,
        `🔹 核心：物理 ${cpu.cores || '?'} / 逻辑 ${cpu.logical_cores || '?'}`,
        `🔹 使用率：${cpu.usage || '?'}%`
      ].join('\n')
    }

    // 内存信息格式化
    let memInfo = '❌ 未获取到内存信息'
    if (device_info.memory && Object.keys(device_info.memory).length > 0) {
      const mem = device_info.memory
      memInfo = [
        `🔹 总量：${mem.total || '?'} GB`,
        `🔹 已用：${mem.used || '?'} GB (${mem.percent || '?'}%)`,
        `🔹 可用：${mem.available || '?'} GB`
      ].join('\n')
    }

    // GPU信息格式化
    let gpuInfo = '❌ 未检测到GPU'
    if (device_info.gpu && Object.keys(device_info.gpu).length > 0) {
      const gpu = device_info.gpu
      gpuInfo = [
        `🔹 名称：${gpu.name || '未知'}`,
        `🔹 驱动：${gpu.driver || '未知'}`,
        `🔹 显存：${gpu.vram_used || '?'}/${gpu.vram_total || '?'} GB (${gpu.vram_percent ? gpu.vram_percent.toFixed(1) : '?'}%)`,
        `🔹 GPU使用率：${gpu.gpu_usage ? gpu.gpu_usage.toFixed(1) : '?'}%`
      ].join('\n')
    }

    await e.reply([
      `📊📊📊 系统状态报告 [${device_info.device_name}]`,
      `⏱️ 更新时间：${timeDiff}秒前`,
      '',
      `🖥️ 操作系统：${masterWindowInfo.device_info.os}`,
      `📱 当前应用：${masterWindowInfo.appName}`,
      `📝 窗口标题：${masterWindowInfo.windowTitle}`,
      '',
      '🧠 CPU信息：',
      cpuInfo,
      '',
      '💾 内存信息：',
      memInfo,
      '',
      '🎮 GPU信息：',
      gpuInfo,
      '',
      '使用命令：',
      '#当前窗口 - 查看活动窗口',
      '#系统状态 - 查看完整系统信息'
    ].join('\n'))

    return true
  }

  // 检查检测状态 - 仅主人可用
  async checkStatus (e) {
    if (!e.isMaster) {
      return false // 非主人直接忽略
    }

    const status = this.isDetectionActive ? '运行中 ✅' : '已停止 ❌'
    const clientStatus = masterWindowInfo
      ? `已连接 (设备: ${masterWindowInfo.deviceName}, ${Math.floor((Date.now() - masterWindowInfo.timestamp) / 1000)}秒前)`
      : '未连接'
    await e.reply([
      '🖥 窗口检测状态',
      `• 服务状态：${status}`,
      `• 客户端状态：${clientStatus}`,
      `• 服务端口：${this.port}`,
      '',
      '使用命令：',
      '#启动窗口检测 - 开启检测',
      '#停止窗口检测 - 停止检测',
      '#当前窗口 - 查看活动窗口'
    ].join('\n'))

    return true
  }

  // 启动检测 - 仅主人可用
  async startDetection (e) {
    if (!e.isMaster) {
      return false // 非主人直接忽略
    }

    if (this.isDetectionActive) {
      await e.reply('窗口检测已在运行中')
      return true
    }

    // 确保服务器已启动
    if (!this.server) {
      await this.startServer()
    }

    this.isDetectionActive = true
    isDetectionActive = true

    await e.reply([
      '✅ 窗口检测已启动',
      '',
      '请确保已运行本地客户端程序',
      `客户端应连接端口: ${this.port}`,
      '',
      '使用"#当前窗口"查看活动窗口'
    ].join('\n'))

    return true
  }

  // 停止检测 - 仅主人可用
  async stopDetection (e) {
    if (!e.isMaster) {
      return false // 非主人直接忽略
    }

    if (!this.isDetectionActive) {
      await e.reply('窗口检测尚未启动')
      return true
    }

    this.isDetectionActive = false
    isDetectionActive = false
    masterWindowInfo = null

    await e.reply('已停止窗口检测')
    return true
  }

  // 插件启用时启动服务器
  async install () {
    await this.startServer()
  }

  // 插件卸载时停止服务器
  async uninstall () {
    await this.stopServer()
    this.isDetectionActive = false
    isDetectionActive = false
    masterWindowInfo = null
  }
}
